```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java堆分代机制详解</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .code-block {
            background-color: #1e293b;
            color: #f8fafc;
            border-radius: 0.5rem;
            padding: 1.5rem;
            font-family: 'Courier New', Courier, monospace;
            position: relative;
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight-text {
            background: linear-gradient(90deg, #f59e0b, #ef4444);
            -webkit-background-clip: text;
            background-clip: text;
            color: transparent;
            font-weight: 600;
        }
        .section-title {
            position: relative;
            padding-bottom: 0.5rem;
        }
        .section-title:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 3rem;
            height: 3px;
            background: linear-gradient(90deg, #4f46e5, #7c3aed);
            border-radius: 3px;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 4rem;
            line-height: 0.8;
            margin-right: 0.5rem;
            color: #4f46e5;
            font-weight: 700;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20">
        <div class="container mx-auto px-6">
            <div class="max-w-4xl mx-auto text-center">
                <h1 class="text-4xl md:text-5xl font-bold mb-6">深入理解Java堆内存分代机制</h1>
                <p class="text-xl md:text-2xl opacity-90 mb-8">探索JVM高效内存管理的核心奥秘</p>
                <div class="flex justify-center">
                    <div class="bg-white bg-opacity-20 px-4 py-2 rounded-full inline-flex items-center">
                        <i class="fas fa-clock mr-2"></i>
                        <span>阅读时间: 10分钟</span>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto px-6 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <p class="drop-cap text-lg md:text-xl text-gray-700 mb-8">Java堆内存是Java虚拟机管理的内存中最大的一块，用于存放对象实例。为了更高效地管理内存和提高垃圾回收的性能，Java堆内存通常被划分为不同的代，每个代具有不同的特点和用途。这种分代的设计是基于分代理论，认为对象的生命周期可以划分为不同的阶段，根据对象的存活时间将堆内存分为不同的区域，从而采用不同的垃圾回收算法和策略来管理内存。</p>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432781072-cdb7c846-1450-4789-9473-2d008f57ebf0.png" alt="Java堆分代结构" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">Java堆内存分代结构示意图</h3>
                        <p class="text-gray-600">图示展示了Java堆内存的典型分代结构，包括新生代(Eden, Survivor)和老年代。</p>
                    </div>
                </div>
                
                <p class="text-lg md:text-xl text-gray-700">这种分代的设计有助于提高Java程序的性能和垃圾回收的效率。不同代采用不同的垃圾回收算法和内存分配策略，使得垃圾回收器可以根据对象的生命周期和内存的使用情况进行灵活的管理和优化。通过合理配置分代大小和选择合适的垃圾回收器，可以有效提高Java程序的性能和稳定性。</p>
            </div>
        </section>

        <!-- Why Generational -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">为什么要分代?</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-6">首先，<span class="highlight-text">为什么要将堆空间分代呢？这是因为不同对象的生命周期不同，经常会有一些对象是临时性的，而另一些对象可能会长时间存活</span>。如果将所有对象都放在同一个堆空间中，垃圾回收会变得非常复杂和低效。因此，将堆空间分为不同代可以更好地适应不同对象的生命周期，从而优化垃圾回收的性能。</p>
                
                <div class="grid md:grid-cols-2 gap-8 mb-8">
                    <div class="bg-white p-6 rounded-xl shadow-md card-hover">
                        <div class="text-indigo-600 mb-4">
                            <i class="fas fa-clock text-3xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold mb-3">对象生命周期的不同阶段</h3>
                        <p class="text-gray-600">Java程序中的对象生命周期可以分为不同的阶段，包括新创建的对象、短时间存活的对象和长时间存活的对象等。这些对象在内存中的存储和回收方式可能有所不同。</p>
                    </div>
                    <div class="bg-white p-6 rounded-xl shadow-md card-hover">
                        <div class="text-indigo-600 mb-4">
                            <i class="fas fa-tachometer-alt text-3xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold mb-3">垃圾回收的性能优化</h3>
                        <p class="text-gray-600">将堆内存分为不同的代，可以针对不同代采用不同的垃圾回收算法和策略，从而提高垃圾回收的性能和效率。</p>
                    </div>
                </div>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1713405030155-922586ec-e2b3-46dc-b71d-5923ba610126.png" alt="分代优势" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">分代设计的优势</h3>
                        <p class="text-gray-600">图示展示了分代设计如何优化垃圾回收性能，减少停顿时间。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <div class="bg-white p-6 rounded-xl shadow-md card-hover">
                        <div class="text-indigo-600 mb-4">
                            <i class="fas fa-memory text-3xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold mb-3">内存分配的优化</h3>
                        <p class="text-gray-600">将堆内存分为不同的代，可以针对不同代采用不同的内存分配策略。例如，在新生代中，通常采用的是分配指针碰撞或者空闲列表等方式进行内存分配。</p>
                    </div>
                    <div class="bg-white p-6 rounded-xl shadow-md card-hover">
                        <div class="text-indigo-600 mb-4">
                            <i class="fas fa-stopwatch text-3xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold mb-3">减少全局垃圾回收停顿</h3>
                        <p class="text-gray-600">将堆内存分为不同的代，可以将垃圾回收的影响局部化，减少全局垃圾回收带来的停顿时间过长的问题。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Generational Theory -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">分代理论的概念</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-8">Java堆的分代设计基于分代理论的概念，该理论认为对象的生命周期可以划分为不同的阶段，并且不同阶段的对象具有不同的存活概率和回收频率。Java堆内存根据分代理论被划分为不同的代（Generation），以更有效地管理内存和提高垃圾回收的性能。</p>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1713404881405-865d137d-f7ab-429f-b3c0-dfb8eea185b9.png" alt="分代理论" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">分代理论示意图</h3>
                        <p class="text-gray-600">图示展示了分代理论的基本概念和Java堆的分代结构。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-indigo-50 p-6 rounded-xl border border-indigo-100 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-indigo-800">新生代 (Young Generation)</h3>
                        <p class="text-gray-700">新生代是Java堆内存的一部分，用于存放新创建的对象。根据分代理论，大多数对象在创建后很快就会被回收，因此新生代被设计为相对较小的区域。</p>
                    </div>
                    <div class="bg-purple-50 p-6 rounded-xl border border-purple-100 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-purple-800">老年代 (Old Generation)</h3>
                        <p class="text-gray-700">老年代用于存放存活时间较长的对象，通常是从新生代晋升过来的对象。根据分代理论，大多数对象在存活一段时间后将会长期存在于内存中。</p>
                    </div>
                    <div class="bg-blue-50 p-6 rounded-xl border border-blue-100 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-blue-800">元数据空间 (Metaspace)</h3>
                        <p class="text-gray-700">在较新的JDK版本中，永久代被元数据空间所取代，元数据空间是在本地内存中分配的，不再受限于Java堆内存大小。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Young Generation -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">新生代详解</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-6">新生代是Java堆内存中的一部分，用于存放新创建的对象。根据对象的生命周期不同，新生代通常包含了大量的短命对象，它们的存活时间较短。新生代通常被进一步划分为Eden空间和两个Survivor空间（通常称为From空间和To空间）。</p>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1706766728630-bcc08644-5a61-43dd-b3e2-42d60ee1e186.png" alt="新生代结构" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">新生代内存结构</h3>
                        <p class="text-gray-600">图示展示了新生代的Eden区和Survivor区的结构及其工作原理。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-indigo-700">复制算法</h3>
                        <p class="text-gray-700 mb-4">新生代采用复制算法（Copying Algorithm）来进行垃圾回收。这种算法将新生代分为两个大小相等的区域，每次只使用其中的一半，将存活的对象复制到另一半区域，然后清空当前区域。</p>
                        <div class="code-block">
                            <div class="flex items-center text-gray-400 mb-2">
                                <i class="fas fa-code mr-2"></i>
                                <span>复制算法伪代码</span>
                            </div>
                            <pre class="text-sm overflow-x-auto">
function copyingGC() {
    for each object in fromSpace {
        if (object is alive) {
            copy object to toSpace
            update references
        }
    }
    swap(fromSpace, toSpace)
    clear toSpace
}</pre>
                        </div>
                    </div>
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-indigo-700">对象晋升流程</h3>
                        <ol class="list-decimal list-inside text-gray-700 space-y-2">
                            <li>新对象首先分配到Eden区</li>
                            <li>Eden区满时触发Minor GC</li>
                            <li>存活对象复制到一个Survivor区</li>
                            <li>Survivor区对象经过多次GC</li>
                            <li>达到年龄阈值的对象晋升到老年代</li>
                        </ol>
                        <div class="mt-4 p-4 bg-indigo-50 rounded-lg">
                            <p class="text-indigo-700"><i class="fas fa-info-circle mr-2"></i>默认晋升年龄阈值是15次GC，可通过参数调整</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Old Generation -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">老年代详解</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-6">老年代主要用于存放长时间存活的对象。在新生代经过多次垃圾回收后，仍然存活的对象会被晋升到老年代。老年代的垃圾回收次数相对较少，采用标记-清除或标记-整理算法来回收垃圾，其主要特点是垃圾回收较少且速度相对较慢。</p>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1706766796571-639b16c8-ad1f-4b2b-9ecb-d8b176f5b859.png" alt="老年代结构" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">老年代内存管理</h3>
                        <p class="text-gray-600">图示展示了老年代的内存结构和垃圾回收过程。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-purple-700">标记-清除算法</h3>
                        <p class="text-gray-700 mb-4">老年代通常采用标记-清除（Mark-Sweep）算法来进行垃圾回收。该算法分为两个阶段：标记阶段标记所有可达对象，清除阶段回收未被标记的对象。</p>
                        <div class="code-block">
                            <div class="flex items-center text-gray-400 mb-2">
                                <i class="fas fa-code mr-2"></i>
                                <span>标记-清除伪代码</span>
                            </div>
                            <pre class="text-sm overflow-x-auto">
function markSweepGC() {
    // 标记阶段
    for each root in roots {
        mark(root)
    }
    
    // 清除阶段
    for each object in heap {
        if (!object.marked) {
            free(object)
        } else {
            object.marked = false
        }
    }
}</pre>
                        </div>
                    </div>
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-purple-700">标记-整理算法</h3>
                        <p class="text-gray-700 mb-4">标记-整理（Mark-Compact）算法在标记阶段与标记-清除相同，但在清除阶段会将所有存活对象向一端移动，然后清理掉边界外的内存。</p>
                        <div class="code-block">
                            <div class="flex items-center text-gray-400 mb-2">
                                <i class="fas fa-code mr-2"></i>
                                <span>标记-整理伪代码</span>
                            </div>
                            <pre class="text-sm overflow-x-auto">
function markCompactGC() {
    // 标记阶段
    for each root in roots {
        mark(root)
    }
    
    // 整理阶段
    compact()
}</pre>
                        </div>
                    </div>
                </div>
                
                <div class="mt-8 p-6 bg-purple-50 rounded-xl border border-purple-100">
                    <h3 class="text-xl font-semibold mb-4 text-purple-800">老年代特点总结</h3>
                    <ul class="list-disc list-inside text-gray-700 space-y-2">
                        <li>存放长期存活的对象，如全局缓存、线程池对象等</li>
                        <li>对象从新生代晋升而来，达到年龄阈值后进入</li>
                        <li>采用标记-清除或标记-整理算法</li>
                        <li>垃圾回收频率低但耗时长（Major GC/Full GC）</li>
                        <li>需要避免内存碎片问题</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Metaspace -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">永久代（元空间）</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-6">永久代主要用于存放类的元数据信息，例如类的信息、方法的信息等。在JDK8及之前的版本中，永久代采用持久化代表垃圾回收（CMS GC）来回收垃圾。而在JDK8之后的版本中，永久代被替换为元空间（Metaspace），元空间不再使用堆内存，而是使用本地内存，这样可以避免堆内存溢出的问题。</p>
                
                <div class="bg-white rounded-xl shadow-lg overflow-hidden mb-8 card-hover">
                    <img src="https://cdn.nlark.com/yuque/0/2023/jpeg/179989/1687246159977-1422ec49-7934-42b8-a180-6b20d7162e52.jpeg" alt="元空间结构" class="w-full h-auto">
                    <div class="p-6">
                        <h3 class="text-2xl font-semibold mb-4">元空间内存结构</h3>
                        <p class="text-gray-600">图示展示了从永久代到元空间的演变及其内存位置变化。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-blue-700">永久代 vs 元空间</h3>
                        <table class="w-full text-sm text-left text-gray-700 border-collapse">
                            <thead class="bg-blue-50">
                                <tr>
                                    <th class="p-3 border border-blue-100">特性</th>
                                    <th class="p-3 border border-blue-100">永久代</th>
                                    <th class="p-3 border border-blue-100">元空间</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr class="border-b border-blue-100">
                                    <td class="p-3 border border-blue-100">位置</td>
                                    <td class="p-3 border border-blue-100">堆内存</td>
                                    <td class="p-3 border border-blue-100">本地内存</td>
                                </tr>
                                <tr class="border-b border-blue-100">
                                    <td class="p-3 border border-blue-100">大小限制</td>
                                    <td class="p-3 border border-blue-100">固定(受MaxPermSize限制)</td>
                                    <td class="p-3 border border-blue-100">动态(受系统内存限制)</td>
                                </tr>
                                <tr class="border-b border-blue-100">
                                    <td class="p-3 border border-blue-100">垃圾回收</td>
                                    <td class="p-3 border border-blue-100">Full GC时回收</td>
                                    <td class="p-3 border border-blue-100">独立回收机制</td>
                                </tr>
                                <tr>
                                    <td class="p-3 border border-blue-100">内存溢出</td>
                                    <td class="p-3 border border-blue-100">常见(PermGen OOM)</td>
                                    <td class="p-3 border border-blue-100">罕见(消耗系统内存)</td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-blue-700">元空间关键配置参数</h3>
                        <div class="code-block">
                            <div class="flex items-center text-gray-400 mb-2">
                                <i class="fas fa-cog mr-2"></i>
                                <span>元空间相关JVM参数</span>
                            </div>
                            <pre class="text-sm overflow-x-auto">
# 设置元空间初始大小
-XX:MetaspaceSize=64m

# 设置元空间最大大小(默认无限制)
-XX:MaxMetaspaceSize=256m

# 设置元空间GC阈值百分比(默认70%)
-XX:MetaspaceSizeThreshold=80

# 设置类元数据回收频率
-XX:MinMetaspaceFreeRatio=40
-XX:MaxMetaspaceFreeRatio=70</pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Object Promotion -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">对象何时进入老年代？</h2>
                
                <p class="text-lg md:text-xl text-gray-700 mb-6">对象何时进入老年代是由Java虚拟机的垃圾回收策略和内存分配机制决定的。一般情况下，对象进入老年代的条件主要取决于两个因素：对象的年龄和晋升阈值。</p>
                
                <div class="grid md:grid-cols-2 gap-8 mb-8">
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-indigo-700">对象的年龄</h3>
                        <p class="text-gray-700 mb-4">Java虚拟机采用了分代的垃圾回收策略，其中包括新生代和老年代。对象在新生代中创建后，会经过一系列的垃圾回收操作。如果对象经过了多次垃圾回收仍然存活下来，那么它的年龄就会逐渐增加。</p>
                        
                        <div class="bg-white p-4 rounded-lg shadow-sm border-l-4 border-indigo-500">
                            <p class="text-indigo-700"><i class="fas fa-exclamation-circle mr-2"></i>默认晋升年龄阈值是15次GC，可通过 <code class="bg-indigo-100 px-1 rounded">-XX:MaxTenuringThreshold</code> 参数调整</p>
                        </div>
                    </div>
                    <div>
                        <h3 class="text-xl font-semibold mb-4 text-indigo-700">晋升阈值</h3>
                        <p class="text-gray-700">除了对象的年龄外，Java虚拟机还会设置一个晋升阈值。当对象的年龄达到这个阈值时，虚拟机会将其晋升到老年代。晋升阈值可以根据应用程序的特性和内存分配情况进行动态调整。</p>
                    </div>
                </div>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <div class="bg-white rounded-xl shadow-lg overflow-hidden card-hover">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1706767308113-16f4d0e3-38c2-41f3-8562-68278e40a965.png" alt="新生代晋升过程" class="w-full h-auto">
                        <div class="p-6">
                            <h3 class="text-2xl font-semibold mb-4">新生代对象晋升过程</h3>
                            <p class="text-gray-600 mb-2">对象首先会被分配到Eden区，当Eden区满时，会触发Minor GC，对Eden区和一个Survivor区进行垃圾回收。存活的对象会被复制到另一个Survivor区。</p>
                            <p class="text-gray-600">在Survivor区经过多次Minor GC后仍然存活的对象，其年龄会逐渐增加(每次gc未回收年龄+1)，当达到一定年龄（默认为15岁）时，会晋升到老年代。</p>
                        </div>
                    </div>
                    <div class="bg-white rounded-xl shadow-lg overflow-hidden card-hover">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1706767118284-1e462680-a151-447f-9974-aff1e943fa36.png" alt="老年代晋升过程" class="w-full h-auto">
                        <div class="p-6">
                            <h3 class="text-2xl font-semibold mb-4">老年代对象晋升过程</h3>
                            <p class="text-gray-600 mb-2">在老年代中，对象的存活时间较长，因此垃圾回收的频率相对较低。当老年代的空间满了时，会触发Major GC或Full GC来进行垃圾回收。</p>
                            <p class="text-gray-600">在垃圾回收过程中，存活的对象会被标记，并未存活的对象会被清理或者整理，以保证老年代中的空间充分利用。</p>
                        </div>
                    </div>
                </div>
                
                <div class="mt-8 p-6 bg-indigo-50 rounded-xl">
                    <h3 class="text-xl font-semibold mb-4 text-indigo-800">对象进入老年代的4种情况</h3>
                    <ol class="list-decimal list-inside text-gray-700 space-y-2">
                        <li><strong>年龄达到阈值</strong>：对象在Survivor区经过多次GC后年龄达到MaxTenuringThreshold值</li>
                        <li><strong>大对象直接分配</strong>：大对象(通过-XX:PretenureSizeThreshold设置)直接进入老年代</li>
                        <li><strong>动态年龄判定</strong>：Survivor区中同年龄对象总大小超过Survivor空间一半时，大于等于该年龄的对象直接进入老年代</li>
                        <li><strong>空间分配担保</strong>：Minor GC后Survivor空间不足时，部分对象会直接进入老年代</li>
                    </ol>
                </div>
            </div>
        </section>

        <!-- Summary -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">总结与关键点</h2>
                
                <div class="grid md:grid-cols-3 gap-6 mb-8">
                    <div class="bg-white p-6 rounded-xl shadow-md border-t-4 border-indigo-500 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-indigo-700">分代设计</h3>
                        <p class="text-gray-700">基于对象生命周期理论，将堆分为新生代和老年代，采用不同的GC算法</p>
                    </div>
                    <div class="bg-white p-6 rounded-xl shadow-md border-t-4 border-purple-500 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-purple-700">新生代特点</h3>
                        <p class="text-gray-700">采用复制算法，包含Eden和Survivor区，GC频繁但快速</p>
                    </div>
                    <div class="bg-white p-6 rounded-xl shadow-md border-t-4 border-blue-500 card-hover">
                        <h3 class="text-xl font-semibold mb-3 text-blue-700">老年代特点</h3>
                        <p class="text-gray-700">采用标记-清除/整理算法，GC次数少但耗时长</p>
                    </div>
                </div>
                
                <div class="bg-gradient-to-r from-indigo-500 to-purple-600 text-white p-8 rounded-xl">
                    <h3 class="text-2xl font-bold mb-4">最佳实践建议</h3>
                    <ul class="list-disc list-inside space-y-2">
                        <li>合理设置各代大小比例(新生代:老年代通常1:2~1:3)</li>
                        <li>监控GC日志调整MaxTenuringThreshold等参数</li>
                        <li>避免创建过多大对象直接进入老年代</li>
                        <li>JDK8+应用适当配置Metaspace大小</li>
                        <li>根据应用特点选择合适的GC收集器组合</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Mermaid Diagram -->
        <section class="mb-16">
            <div class="max-w-4xl mx-auto">
                <h2 class="text-3xl font-bold mb-8 section-title">Java堆分代全貌</h2>
                
                <div class="bg-white p-6 rounded-xl shadow-lg">
                    <div class="mermaid">
                        graph TD
                            A[Java堆内存] --> B[新生代 Young Generation]
                            A --> C[老年代 Old Generation]
                            A --> D[元空间 Metaspace]
                            
                            B --> E[Eden区]
                            B --> F[Survivor区 From]
                            B --> G[Survivor区 To]
                            
                            style A fill:#4f46e5,stroke:#4f46e5,color:white
                            style B fill:#7c3aed,stroke:#7c3aed,color:white
                            style C fill:#6b21a8,stroke:#6b21a8,color:white
                            style D fill:#4338ca,stroke:#4338ca,color:white
                            style E fill:#a78bfa,stroke:#7c3aed
                            style F fill:#a78bfa,stroke:#7c3aed
                            style G fill:#a78bfa,stroke:#7c3aed
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto px-6">
            <div class="max-w-4xl mx-auto text-center">
                <h3 class="text-xl font-semibold mb-2">技术小馆</h3>
                <p class="mb-4">探索技术奥秘，分享知识精华</p>
                <a href="http://www.yuque.com/jtostring" class="text-indigo-400 hover:text-indigo-300 transition-colors" target="_blank">
                    <i class="fas fa-external-link-alt mr-1"></i>www.yuque.com/jtostring
                </a>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 平滑滚动
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>
```